import mqtt from "mqtt/dist/mqtt"
// import store from '@/store';

export let is_connected = false;
const {
	host = '120.79.227.98', port = '1883'
} = uni.getStorageSync('mqttConfig') || {};

// 检测平台并选择合适的协议
function getMqttUrl(host, port) {
	// 对于App端和H5端，使用不同的连接方式
	// #ifdef APP-PLUS
	// App端尝试直接TCP连接
	return `mqtt://${host}:${port}`;
	// #endif
	
	// #ifdef H5
	// H5端需要WebSocket连接，通常需要WebSocket代理
	return `ws://${host}:8083`;
	// #endif
	
	// #ifdef MP-WEIXIN
	// 微信小程序使用wx协议
	return `wx://${host}:8083/mqtt`;
	// #endif
	
	// 默认尝试WebSocket
	return `ws://${host}:8083`;
}

// MQTT 服务配置
const MQTT_BROKER_URL = getMqttUrl(host, port);
const MQTT_OPTIONS = {
	clientId: `uniapp_${Math.random().toString(16).substr(2, 8)}`,
	username: 'zh_mqtt',
	password: 'mD3q6tC$HPHe^@6T',
	keepalive: 60,
	clean: true,
	reconnectPeriod: 5000, // 增加重连间隔到5秒
	connectTimeout: 10000, // 连接超时10秒
	rejectUnauthorized: false // 忽略SSL证书验证
};


export let client = null;
const topicCallbackMap = new Map(); // 存储每个主题对应的回调函数列表

// 连接管理变量
let reconnectAttempts = 0;
const MAX_RECONNECT_ATTEMPTS = 5;
let isConnecting = false;

// 可尝试的连接方式列表
const CONNECTION_URLS = [
	`mqtt://${host}:${port}`,        // 标准MQTT TCP连接
	`ws://${host}:8083`,             // WebSocket连接（如果有代理）
	`ws://${host}:${port}`,          // WebSocket直连
	`wx://${host}:8083/mqtt`,        // 微信小程序协议
];

let currentUrlIndex = 0;

/**
 * 检查目标 topic 是否匹配订阅的 pattern（支持 + 通配符）
 * @param {string} pattern - 订阅的主题模式（如 "rtk/base_station/+"）
 * @param {string} topic - 实际收到的消息主题（如 "rtk/base_station/station1"）
 * @returns {boolean} - 是否匹配
 */
function isTopicMatch(pattern, topic) {
	const patternParts = pattern.split('/');
	const topicParts = topic.split('/');

	if (patternParts.length !== topicParts.length) {
		return false; // 层数不同，直接不匹配
	}

	for (let i = 0; i < patternParts.length; i++) {
		if (patternParts[i] === '+') {
			continue; // + 通配符匹配任意单层
		}
		if (patternParts[i] !== topicParts[i]) {
			return false; // 不匹配
		}
	}

	return true; // 完全匹配
}

// 尝试下一个连接URL
function tryNextConnection() {
	if (currentUrlIndex >= CONNECTION_URLS.length) {
		console.error('❌ 所有连接方式都已尝试，连接失败');
		isConnecting = false;
		is_connected = false;
		return false;
	}
	
	const url = CONNECTION_URLS[currentUrlIndex];
	console.log(`🔗 尝试连接方式 ${currentUrlIndex + 1}/${CONNECTION_URLS.length}: ${url}`);
	
	// 清理之前的客户端
	if (client) {
		try {
			client.removeAllListeners();
			client.end(true);
		} catch (e) {
			console.warn('清理旧客户端时出错:', e);
		}
		client = null;
	}
	
	try {
		client = mqtt.connect(url, MQTT_OPTIONS);
		setupClientEventHandlers();
		return true;
	} catch (error) {
		console.error(`连接失败: ${url}`, error);
		currentUrlIndex++;
		return tryNextConnection();
	}
}

function setupClientEventHandlers() {
	if (!client) return;
	
	// 连接成功处理
	client.on('connect', () => {
		console.log(`✅ MQTT连接成功，使用: ${CONNECTION_URLS[currentUrlIndex]}`);
		is_connected = true;
		isConnecting = false;
		reconnectAttempts = 0;
		// 记住成功的连接方式，下次优先使用
		CONNECTION_URLS.unshift(CONNECTION_URLS.splice(currentUrlIndex, 1)[0]);
		currentUrlIndex = 0;
	});

	// 消息处理
	client.on('message', (topic, message) => {
		console.log(`📨 收到消息 - 主题: ${topic}, 内容: ${message.toString()}`);

		// 先尝试精确匹配
		let callbacks = topicCallbackMap.get(topic);
		if (callbacks) {
			callbacks.forEach(callback => {
				try {
					callback(topic, message);
				} catch (error) {
					console.error('回调函数执行错误:', error);
				}
			});
		} else {
			// 如果没有精确匹配，尝试通配符匹配
			let matched = false;
			topicCallbackMap.forEach((callbacks, pattern) => {
				if (isTopicMatch(pattern, topic)) {
					callbacks.forEach(cb => {
						try {
							cb(topic, message);
						} catch (error) {
							console.error('通配符回调函数执行错误:', error);
						}
					});
					matched = true;
				}
			});

			if (!matched) {
				console.log(`⚠️ 没有找到匹配的回调 for 主题: ${topic}`);
			}
		}
	});

	// 错误处理
	client.on('error', (err) => {
		console.error(`❌ MQTT 连接错误 (${CONNECTION_URLS[currentUrlIndex]}):`, err);
		
		// 尝试下一个连接方式
		currentUrlIndex++;
		if (!tryNextConnection()) {
			isConnecting = false;
			handleDisconnection('所有连接方式都失败');
		}
	});
	
	// 连接关闭处理
	client.on('close', () => {
		console.log(`🔌 连接已关闭: ${CONNECTION_URLS[currentUrlIndex] || '未知'}`);
		isConnecting = false;
		handleDisconnection('MQTT 连接已断开');
	});
	
	// 重连处理
	client.on('reconnect', () => {
		reconnectAttempts++;
		console.log(`🔄 MQTT 正在尝试重连... (${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
		
		if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
			console.warn('⚠️ 达到最大重连次数，尝试下一个连接方式');
			currentUrlIndex++;
			reconnectAttempts = 0;
			
			if (!tryNextConnection()) {
				console.error('❌ 所有连接方式都已尝试完毕');
				client.end(true);
				is_connected = false;
				isConnecting = false;
			}
		}
	});
	
	// 断开连接处理
	client.on('disconnect', () => {
		isConnecting = false;
		handleDisconnection('MQTT disconnect');
	});
	
	// 离线处理
	client.on('offline', () => {
		isConnecting = false;
		handleDisconnection('MQTT 客户端离线');
	});
}

export function connectMqtt(url = null) {
	// 防止重复连接
	if (isConnecting || (client && client.connected)) {
		console.log('MQTT已连接或正在连接中');
		return;
	}
	
	isConnecting = true;
	currentUrlIndex = 0;
	console.info('🚀 开始智能MQTT连接');

	// 如果指定了URL，优先使用
	if (url) {
		CONNECTION_URLS.unshift(url);
	}

	if (!tryNextConnection()) {
		console.error('❌ 无法建立MQTT连接');
		isConnecting = false;
	}
}

// 简单的主题匹配函数，支持 + 和 #
// const matchTopic = (pattern, topic) => {
// 	const patternParts = pattern.split('/');
// 	const topicParts = topic.split('/');

// 	if (patternParts.length !== topicParts.length) return false;

// 	for (let i = 0; i < patternParts.length; i++) {
// 		const p = patternParts[i];
// 		const t = topicParts[i];

// 		if (p === '+') {
// 			continue; // 匹配任意单个部分
// 		} else if (p === '#') {
// 			return true; // # 可以匹配剩余所有部分
// 		} else if (p !== t) {
// 			return false;
// 		}
// 	}

// 	return true;
// };

function handleDisconnection(message) {
	console.warn(`🔌 ${message}`);
	is_connected = false;
	isConnecting = false;
}

export function registerCallback(topic, callback) {
	if (!topicCallbackMap.has(topic)) topicCallbackMap.set(topic, new Set());
	topicCallbackMap.get(topic).add(callback);
}

// export function unregisterCallback(topic, callback) {
// 	const callbacks = topicCallbackMap.get(topic);
// 	if (callbacks) {
// 		const index = callbacks.indexOf(callback);
// 		if (index > -1) callbacks.splice(index, 1);
// 	}
// }
export function unregisterCallback(topic, callback) {
	if (topicCallbackMap.has(topic)) {
		const callbacks = topicCallbackMap.get(topic);
		const removed = callbacks.delete(callback);
		if (removed && callbacks.size === 0) {
			topicCallbackMap.delete(topic);
			console.log(`已删除空的主题条目: ${topic}`);
		}
	}
}

export function publishMessage(topic, message) {
  if (is_connected && client) {
    client.publish(
      topic,
      message,
      {
        qos: 0,
        retain: false,
      },
      (err) => {
        if (err) {
          console.error('❌ 发布消息失败:', err);
        } else {
          console.log(`📤 消息已发布到 ${topic}: ${message}`);
        }
      }
    );
    return true; // 已尝试发送
  } else {
    warnAndToast('MQTT 未连接，发布消息失败');
    return false; // 未连接，未发送
  }
}

export function subscribe(topic, callback) {
	if (client && client.connected) {
		client.subscribe(topic, (err) => {
			if (!err) {
				console.log(`成功订阅: ${topic}`);
				if (callback && typeof callback === 'function') registerCallback(topic, callback);
			} else {
				console.error(`订阅失败: ${topic}`, err);
			}
		});
	} else {
		warnAndToast(`MQTT 未连接，无法订阅主题: ${topic}`);
	}
}

export function unsubscribe(topic, callback) {
	if (client && client.connected) {
		client.unsubscribe(topic, (err) => {
			if (!err) {
				unregisterCallback(topic, callback);
				console.log(`已取消订阅: ${topic}`);
			} else {
				console.error(`取消订阅失败: ${topic}`, err);
			}
		});
	} else {
		console.warn(`MQTT 未连接，无法取消订阅: ${topic}`);
	}
}

export function disconnectMQTT() {
	console.log('🔌 断开MQTT连接');
	
	// 重置状态
	is_connected = false;
	isConnecting = false;
	reconnectAttempts = 0;
	
	if (client) {
		try {
			// 移除所有事件监听器，防止重连
			client.removeAllListeners();
			
			if (client.connected) {
				client.end(true, () => {
					console.log('✅ MQTT连接已优雅关闭');
				});
			} else {
				client.end(true);
			}
		} catch (error) {
			console.warn('断开MQTT连接时出错:', error);
		}
		
		client = null;
	}
	
	// 清理回调映射
	topicCallbackMap.clear();
}

function warnAndToast(message) {
	connectMqtt();
	console.warn(message);
	uni.showToast({
		title: message,
		icon: 'none'
	});
}